/**
 * 灵感库AI增强服务
 * 提供自动分类、摘要生成、相关推荐等功能
 */

import { generationService } from './generation.service';
import { useModelConfigStore } from '@/stores/model-config.store';
import type { InspirationItem } from '@/types/brainstorm';

interface AIEnhancementResult {
  suggestedTags: string[];
  summary: string;
  category: string;
  qualityScore: number;
  keywords: string[];
}

interface RecommendationResult {
  recommendations: InspirationItem[];
  reason: string;
}

class InspirationAIService {
  /**
   * AI自动分类素材
   * 分析内容并建议适当的标签和分类
   */
  async classifyInspiration(item: InspirationItem): Promise<AIEnhancementResult> {
    try {
      // 获取第一个可用的模型配置
      const config = this.getAvailableModel();
      if (!config) {
        throw new Error('没有可用的AI模型');
      }

      const prompt = `请分析以下灵感素材，并提供分类建议。

【素材标题】
${item.title}

【素材内容】
${item.content}

【当前标签】
${item.tags.join(', ') || '无'}

请以JSON格式返回分析结果：
{
  "suggestedTags": ["建议标签1", "建议标签2", "建议标签3"],
  "summary": "50字以内的摘要",
  "category": "内容类别（如：技术、产品、营销、新闻等）",
  "qualityScore": 85,
  "keywords": ["关键词1", "关键词2", "关键词3"]
}

只返回JSON，不要额外说明。`;

      const response = await generationService.generate({
        model: config.modelName,
        provider: config.providerId,
        apiKey: config.apiKey,
        baseUrl: config.baseUrl,
        messages: [
          {
            role: 'system',
            content: '你是一个专业的内容分析师，擅长分类和总结各类文本内容。'
          },
          {
            role: 'user',
            content: prompt
          }
        ],
        parameters: {
          temperature: 0.3,
          maxTokens: 500,
          topP: 0.9
        },
        stream: false
      });

      const result = this.extractJSON(response.content);
      return result;
    } catch (error) {
      console.error('AI分类失败:', error);
      // 返回基础分类结果
      return this.getFallbackClassification(item);
    }
  }

  /**
   * 提取素材摘要
   */
  async generateSummary(content: string, maxLength: number = 100): Promise<string> {
    try {
      const config = this.getAvailableModel();
      if (!config) {
        throw new Error('没有可用的AI模型');
      }

      const prompt = `请为以下内容生成一个${maxLength}字以内的摘要：

${content}

只返回摘要文本，不要其他内容。`;

      const response = await generationService.generate({
        model: config.modelName,
        provider: config.providerId,
        apiKey: config.apiKey,
        baseUrl: config.baseUrl,
        messages: [
          {
            role: 'system',
            content: '你是一个专业的内容摘要生成器，擅长提取核心要点。'
          },
          {
            role: 'user',
            content: prompt
          }
        ],
        parameters: {
          temperature: 0.3,
          maxTokens: 200,
          topP: 0.9
        },
        stream: false
      });

      return response.content.trim();
    } catch (error) {
      console.error('生成摘要失败:', error);
      // 返回前100个字符作为摘要
      return content.substring(0, maxLength) + (content.length > maxLength ? '...' : '');
    }
  }

  /**
   * 相关素材推荐
   * 基于当前素材推荐相似或相关的其他素材
   */
  async getRecommendations(
    currentItem: InspirationItem,
    allItems: InspirationItem[],
    limit: number = 5
  ): Promise<RecommendationResult> {
    try {
      // 排除当前素材
      const candidates = allItems.filter(item => item.id !== currentItem.id);

      if (candidates.length === 0) {
        return {
          recommendations: [],
          reason: '暂无其他素材'
        };
      }

      // 简单的相似度计算（基于标签和关键词匹配）
      const scoredItems = candidates.map(item => {
        let score = 0;

        // 标签匹配
        const commonTags = item.tags.filter(tag => currentItem.tags.includes(tag));
        score += commonTags.length * 3;

        // 内容类型匹配
        if (item.type === currentItem.type) {
          score += 2;
        }

        // 内容关键词匹配（简单的文本相似度）
        const currentWords = currentItem.content.toLowerCase().split(/\s+/);
        const itemWords = item.content.toLowerCase().split(/\s+/);
        const commonWords = currentWords.filter(word =>
          word.length > 3 && itemWords.includes(word)
        );
        score += commonWords.length * 0.5;

        return { item, score };
      });

      // 排序并取前N个
      const recommendations = scoredItems
        .filter(({ score }) => score > 0)
        .sort((a, b) => b.score - a.score)
        .slice(0, limit)
        .map(({ item }) => item);

      // 生成推荐理由
      let reason = '';
      if (recommendations.length > 0) {
        const commonTags = recommendations[0].tags.filter(tag =>
          currentItem.tags.includes(tag)
        );
        if (commonTags.length > 0) {
          reason = `这些素材与当前素材有共同标签：${commonTags.join('、')}`;
        } else {
          reason = '这些素材内容相关';
        }
      }

      return {
        recommendations,
        reason
      };
    } catch (error) {
      console.error('获取推荐失败:', error);
      return {
        recommendations: [],
        reason: '推荐失败'
      };
    }
  }

  /**
   * 批量AI增强
   * 对多个素材进行批量分类和摘要
   */
  async batchEnhance(items: InspirationItem[]): Promise<Map<string, AIEnhancementResult>> {
    const results = new Map<string, AIEnhancementResult>();

    // 限制并发数量，避免API调用过多
    const batchSize = 3;
    for (let i = 0; i < items.length; i += batchSize) {
      const batch = items.slice(i, i + batchSize);
      const batchPromises = batch.map(item =>
        this.classifyInspiration(item)
          .then(result => ({ id: item.id, result }))
          .catch(error => {
            console.error(`增强素材 ${item.id} 失败:`, error);
            return { id: item.id, result: this.getFallbackClassification(item) };
          })
      );

      const batchResults = await Promise.all(batchPromises);
      batchResults.forEach(({ id, result }) => {
        results.set(id, result);
      });

      // 避免请求过快
      if (i + batchSize < items.length) {
        await this.sleep(1000);
      }
    }

    return results;
  }

  /**
   * 素材去重检测
   * 检测是否有相似或重复的素材
   */
  async detectDuplicates(
    newItem: InspirationItem,
    existingItems: InspirationItem[]
  ): Promise<{ isDuplicate: boolean; similarItems: InspirationItem[] }> {
    const similarItems: InspirationItem[] = [];

    for (const existing of existingItems) {
      // 标题完全相同
      if (newItem.title.trim() === existing.title.trim()) {
        similarItems.push(existing);
        continue;
      }

      // 内容高度相似（简单的字符串相似度）
      const similarity = this.calculateSimilarity(
        newItem.content,
        existing.content
      );

      if (similarity > 0.8) {
        similarItems.push(existing);
      }
    }

    return {
      isDuplicate: similarItems.length > 0,
      similarItems
    };
  }

  /**
   * 素材质量评分
   * 根据多个维度评估素材质量
   */
  evaluateQuality(item: InspirationItem): number {
    let score = 0;

    // 标题质量（10分）
    if (item.title && item.title.length > 5) {
      score += Math.min(10, item.title.length / 2);
    }

    // 内容长度（30分）
    const contentLength = item.content.length;
    if (contentLength > 50) {
      score += Math.min(30, contentLength / 10);
    }

    // 标签数量（20分）
    score += Math.min(20, item.tags.length * 5);

    // 来源信息（10分）
    if (item.source && item.source.url) {
      score += 10;
    }

    // 时效性（10分）
    const createdAt = new Date(item.createdAt);
    const daysSinceCreation = (Date.now() - createdAt.getTime()) / (1000 * 60 * 60 * 24);
    if (daysSinceCreation < 7) {
      score += 10;
    } else if (daysSinceCreation < 30) {
      score += 5;
    }

    // 结构化程度（20分）
    if (item.content.includes('\n') || item.content.includes('###') || item.content.includes('##')) {
      score += 10;
    }
    if (item.content.match(/\d+\./g)) {
      score += 10;
    }

    return Math.min(100, Math.round(score));
  }

  /**
   * 提取关键词
   */
  async extractKeywords(content: string, limit: number = 5): Promise<string[]> {
    try {
      const config = this.getAvailableModel();
      if (!config) {
        throw new Error('没有可用的AI模型');
      }

      const prompt = `请从以下内容中提取${limit}个最重要的关键词：

${content}

只返回关键词列表，每行一个关键词，不要编号或其他符号。`;

      const response = await generationService.generate({
        model: config.modelName,
        provider: config.providerId,
        apiKey: config.apiKey,
        baseUrl: config.baseUrl,
        messages: [
          {
            role: 'system',
            content: '你是一个专业的关键词提取专家。'
          },
          {
            role: 'user',
            content: prompt
          }
        ],
        parameters: {
          temperature: 0.2,
          maxTokens: 100,
          topP: 0.9
        },
        stream: false
      });

      // 解析返回的关键词
      const keywords = response.content
        .split('\n')
        .map(line => line.trim())
        .filter(line => line.length > 0 && line.length < 20)
        .slice(0, limit);

      return keywords;
    } catch (error) {
      console.error('提取关键词失败:', error);
      return [];
    }
  }

  // ========== 辅助方法 ==========

  /**
   * 获取可用的AI模型配置
   */
  private getAvailableModel() {
    const { configs } = useModelConfigStore.getState();
    const availableConfigs = configs.filter(
      c => c.isActive && c.status === 'healthy' && c.apiKey
    );
    return availableConfigs[0] || null;
  }

  /**
   * 从AI响应中提取JSON
   */
  private extractJSON(text: string): any {
    try {
      return JSON.parse(text);
    } catch (e) {
      // 尝试提取JSON代码块
      const jsonBlockMatch = text.match(/```json\s*([\s\S]*?)\s*```/);
      if (jsonBlockMatch) {
        try {
          return JSON.parse(jsonBlockMatch[1]);
        } catch (e2) {
          // 继续尝试其他方法
        }
      }

      // 尝试提取花括号内容
      const braceMatch = text.match(/\{[\s\S]*\}/);
      if (braceMatch) {
        try {
          return JSON.parse(braceMatch[0]);
        } catch (e3) {
          // 继续尝试其他方法
        }
      }

      throw new Error('无法从响应中提取有效的JSON');
    }
  }

  /**
   * 获取后备分类结果
   */
  private getFallbackClassification(item: InspirationItem): AIEnhancementResult {
    // 基于内容长度和现有标签提供简单的分类
    const contentLength = item.content.length;
    const existingTags = item.tags;

    return {
      suggestedTags: existingTags.length > 0 ? existingTags : ['未分类'],
      summary: item.content.substring(0, 50) + (contentLength > 50 ? '...' : ''),
      category: this.guessCategory(item),
      qualityScore: this.evaluateQuality(item),
      keywords: this.extractSimpleKeywords(item.content)
    };
  }

  /**
   * 简单的类别猜测
   */
  private guessCategory(item: InspirationItem): string {
    const content = (item.title + ' ' + item.content).toLowerCase();

    if (content.includes('技术') || content.includes('代码') || content.includes('开发')) {
      return '技术';
    }
    if (content.includes('产品') || content.includes('功能') || content.includes('设计')) {
      return '产品';
    }
    if (content.includes('营销') || content.includes('文案') || content.includes('广告')) {
      return '营销';
    }
    if (content.includes('新闻') || content.includes('报道') || content.includes('事件')) {
      return '新闻';
    }

    return '其他';
  }

  /**
   * 简单的关键词提取（不使用AI）
   */
  private extractSimpleKeywords(content: string): string[] {
    // 简单分词并统计词频
    const words = content
      .toLowerCase()
      .replace(/[^\u4e00-\u9fa5a-z0-9\s]/g, ' ')
      .split(/\s+/)
      .filter(word => word.length > 2);

    const wordFreq = new Map<string, number>();
    words.forEach(word => {
      wordFreq.set(word, (wordFreq.get(word) || 0) + 1);
    });

    // 排序并取前5个
    return Array.from(wordFreq.entries())
      .sort((a, b) => b[1] - a[1])
      .slice(0, 5)
      .map(([word]) => word);
  }

  /**
   * 计算文本相似度（简单版本）
   */
  private calculateSimilarity(text1: string, text2: string): number {
    const words1 = new Set(text1.toLowerCase().split(/\s+/));
    const words2 = new Set(text2.toLowerCase().split(/\s+/));

    const intersection = new Set([...words1].filter(x => words2.has(x)));
    const union = new Set([...words1, ...words2]);

    return intersection.size / union.size;
  }

  /**
   * 延迟函数
   */
  private sleep(ms: number): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

export const inspirationAIService = new InspirationAIService();
